package com.imut.lagain.service.impl;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.imut.lagain.constant.AppConstants;
import com.imut.lagain.service.ICacheService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * 缓存服务实现类
 * 提供统一的Redis缓存操作
 */
@Service
@Primary
public class CacheServiceImpl implements ICacheService {
    
    private static final Logger log = LoggerFactory.getLogger(CacheServiceImpl.class);
    
    private final RedisTemplate<String, Object> redisTemplate;
    private final StringRedisTemplate stringRedisTemplate;
    private final ObjectMapper objectMapper;

    public CacheServiceImpl(RedisTemplate<String, Object> redisTemplate, 
            StringRedisTemplate stringRedisTemplate,
            ObjectMapper objectMapper) {
        this.redisTemplate = redisTemplate;
        this.stringRedisTemplate = stringRedisTemplate;
        this.objectMapper = objectMapper;
    }

    /**
     * 设置缓存
     * @param key 键
     * @param value 值
     * @return 是否设置成功
     */
    @Override
    public Boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            log.debug("设置缓存: key={}, value={}", key, value);
            return true;
        } catch (Exception e) {
            log.error("设置缓存失败: key={}, value={}", key, value, e);
            return false;
        }
    }

    /**
     * 设置缓存并指定过期时间
     * @param key 键
     * @param value 值
     * @param timeout 过期时间
     * @param unit 时间单位
     * @return 是否设置成功
     */
    @Override
    public Boolean set(String key, Object value, long timeout, TimeUnit unit) {
        try {
            redisTemplate.opsForValue().set(key, value, timeout, unit);
            log.debug("设置缓存: key={}, value={}, timeout={}, unit={}", key, value, timeout, unit);
            return true;
        } catch (Exception e) {
            log.error("设置缓存失败: key={}, value={}, timeout={}, unit={}", key, value, timeout, unit, e);
            return false;
        }
    }

    /**
     * 设置缓存并指定过期时间（秒）
     * @param key 键
     * @param value 值
     * @param timeout 过期时间（秒）
     * @return 是否设置成功
     */
    @Override
    public Boolean setEx(String key, Object value, long timeout) {
        return set(key, value, timeout, TimeUnit.SECONDS);
    }

    /**
     * 获取缓存
     * @param key 键
     * @return 值
     */
    @Override
    public Object get(String key) {
        try {
            return redisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            log.error("获取缓存失败: key={}", key, e);
            return null;
        }
    }

    /**
     * 获取缓存并转换为指定类型
     * @param key 键
     * @param clazz 目标类型
     * @return 值
     */
    @Override
    public <T> T get(String key, Class<T> clazz) {
        try {
            Object value = get(key);
            if (value == null) {
                return null;
            }
            if (clazz.isInstance(value)) {
                return clazz.cast(value);
            }
            return objectMapper.convertValue(value, clazz);
        } catch (Exception e) {
            log.error("获取缓存失败: key={}, clazz={}", key, clazz, e);
            return null;
        }
    }

    /**
     * 检查键是否存在
     * @param key 键
     * @return 是否存在
     */
    @Override
    public Boolean hasKey(String key) {
        try {
            Boolean exists = redisTemplate.hasKey(key);
            return exists != null ? exists : false;
        } catch (Exception e) {
            log.error("检查键是否存在失败: key={}", key, e);
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 键
     * @return 是否删除成功
     */
    @Override
    public Boolean delete(String key) {
        try {
            Boolean result = redisTemplate.delete(key);
            log.debug("删除缓存: key={}, result={}", key, result);
            return result;
        } catch (Exception e) {
            log.error("删除缓存失败: key={}", key, e);
            return false;
        }
    }

    /**
     * 批量删除缓存
     * @param keys 键集合
     * @return 删除的数量
     */
    @Override
    public Long delete(Collection<String> keys) {
        try {
            Long result = redisTemplate.delete(keys);
            log.debug("批量删除缓存: keys={}, result={}", keys, result);
            return result;
        } catch (Exception e) {
            log.error("批量删除缓存失败: keys={}", keys, e);
            return 0L;
        }
    }

    /**
     * 设置过期时间
     * @param key 键
     * @param timeout 过期时间
     * @param unit 时间单位
     * @return 是否设置成功
     */
    @Override
    public Boolean expire(String key, long timeout, TimeUnit unit) {
        try {
            Boolean result = redisTemplate.expire(key, timeout, unit);
            log.debug("设置过期时间: key={}, timeout={}, unit={}, result={}", key, timeout, unit, result);
            return result;
        } catch (Exception e) {
            log.error("设置过期时间失败: key={}, timeout={}, unit={}", key, timeout, unit, e);
            return false;
        }
    }

    /**
     * 获取过期时间
     * @param key 键
     * @return 过期时间（秒）
     */
    @Override
    public Long getExpire(String key) {
        try {
            return redisTemplate.getExpire(key);
        } catch (Exception e) {
            log.error("获取过期时间失败: key={}", key, e);
            return -1L;
        }
    }

    /**
     * 根据模式查找键
     * @param pattern 模式
     * @return 键集合
     */
    @Override
    public Set<String> keys(String pattern) {
        try {
            return redisTemplate.keys(pattern);
        } catch (Exception e) {
            log.error("根据模式查找键失败: pattern={}", pattern, e);
            return Set.of();
        }
    }

    /**
     * 获取字符串缓存
     * @param key 键
     * @return 值
     */
    @Override
    public String getString(String key) {
        try {
            return stringRedisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            log.error("获取字符串缓存失败: key={}", key, e);
            return null;
        }
    }

    /**
     * 设置字符串缓存
     * @param key 键
     * @param value 值
     * @return 是否设置成功
     */
    @Override
    public Boolean setString(String key, String value) {
        try {
            stringRedisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.error("设置字符串缓存失败: key={}, value={}", key, value, e);
            return false;
        }
    }

    /**
     * 设置字符串缓存并指定过期时间
     * @param key 键
     * @param value 值
     * @param timeout 过期时间
     * @param unit 时间单位
     * @return 是否设置成功
     */
    @Override
    public Boolean setString(String key, String value, long timeout, TimeUnit unit) {
        try {
            stringRedisTemplate.opsForValue().set(key, value, timeout, unit);
            return true;
        } catch (Exception e) {
            log.error("设置字符串缓存失败: key={}, value={}, timeout={}, unit={}", key, value, timeout, unit, e);
            return false;
        }
    }

    /**
     * 设置字符串缓存并指定过期时间
     * @param key 键
     * @param value 值
     * @param timeout 过期时间（秒）
     * @return 是否设置成功
     */
    public Boolean setStringEx(String key, String value, long timeout) {
        try {
            stringRedisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
            return true;
        } catch (Exception e) {
            log.error("设置字符串缓存失败: key={}, value={}, timeout={}", key, value, timeout, e);
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @param delta 增量
     * @return 递增后的值
     */
    @Override
    public Long increment(String key, long delta) {
        try {
            return redisTemplate.opsForValue().increment(key, delta);
        } catch (Exception e) {
            log.error("递增失败: key={}, delta={}", key, delta, e);
            return null;
        }
    }

    /**
     * 递增计数器
     * @param key 键
     * @return 递增后的值
     */
    @Override
    public Long increment(String key) {
        try {
            return redisTemplate.opsForValue().increment(key, 1);
        } catch (Exception e) {
            log.error("递增计数器失败: key={}", key, e);
            return null;
        }
    }

    /**
     * 递减
     * @param key 键
     * @param delta 减量
     * @return 递减后的值
     */
    @Override
    public Long decrement(String key, long delta) {
        try {
            return redisTemplate.opsForValue().decrement(key, delta);
        } catch (Exception e) {
            log.error("递减失败: key={}, delta={}", key, delta, e);
            return null;
        }
    }

    /**
     * 递减计数器
     * @param key 键
     * @return 递减后的值
     */
    @Override
    public Long decrement(String key) {
        try {
            return redisTemplate.opsForValue().decrement(key, 1);
        } catch (Exception e) {
            log.error("递减计数器失败: key={}", key, e);
            return null;
        }
    }

    // Hash操作
    /**
     * 设置哈希字段
     * @param key 键
     * @param hashKey 哈希键
     * @param value 值
     * @return 是否设置成功
     */
    @Override
    public Boolean hSet(String key, String hashKey, Object value) {
        try {
            redisTemplate.opsForHash().put(key, hashKey, value);
            return true;
        } catch (Exception e) {
            log.error("设置哈希字段失败: key={}, hashKey={}, value={}", key, hashKey, value, e);
            return false;
        }
    }

    /**
     * 获取哈希字段
     * @param key 键
     * @param hashKey 哈希键
     * @return 值
     */
    @Override
    public Object hGet(String key, String hashKey) {
        try {
            return redisTemplate.opsForHash().get(key, hashKey);
        } catch (Exception e) {
            log.error("获取哈希字段失败: key={}, hashKey={}", key, hashKey, e);
            return null;
        }
    }

    /**
     * 获取哈希字段并转换为指定类型
     * @param key 键
     * @param hashKey 哈希键
     * @param clazz 目标类型
     * @return 值
     */
    @Override
    public <T> T hGet(String key, String hashKey, Class<T> clazz) {
        try {
            Object value = hGet(key, hashKey);
            if (value == null) {
                return null;
            }
            if (clazz.isInstance(value)) {
                return clazz.cast(value);
            }
            return objectMapper.convertValue(value, clazz);
        } catch (Exception e) {
            log.error("获取哈希字段失败: key={}, hashKey={}, clazz={}", key, hashKey, clazz, e);
            return null;
        }
    }

    /**
     * 批量设置哈希字段
     * @param key 键
     * @param map 哈希表
     * @return 是否设置成功
     */
    @Override
    public Boolean hMSet(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            log.error("批量设置哈希字段失败: key={}, map={}", key, map, e);
            return false;
        }
    }

    /**
     * 批量获取哈希字段
     * @param key 键
     * @param hashKeys 哈希键集合
     * @return 值列表
     */
    @Override
    public List<Object> hMGet(String key, Collection<Object> hashKeys) {
        try {
            return redisTemplate.opsForHash().multiGet(key, hashKeys);
        } catch (Exception e) {
            log.error("批量获取哈希字段失败: key={}, hashKeys={}", key, hashKeys, e);
            return List.of();
        }
    }

    /**
     * 删除哈希字段
     * @param key 键
     * @param hashKeys 哈希键
     * @return 删除的数量
     */
    @Override
    public Long hDelete(String key, Object... hashKeys) {
        try {
            return redisTemplate.opsForHash().delete(key, hashKeys);
        } catch (Exception e) {
            log.error("删除哈希字段失败: key={}, hashKeys={}", key, hashKeys, e);
            return 0L;
        }
    }

    /**
     * 获取所有哈希字段
     * @param key 键
     * @return 哈希表
     */
    @Override
    public Map<Object, Object> hGetAll(String key) {
        try {
            return redisTemplate.opsForHash().entries(key);
        } catch (Exception e) {
            log.error("获取所有哈希字段失败: key={}", key, e);
            return Map.of();
        }
    }

    /**
     * 获取哈希表所有键
     * @param key 键
     * @return 键集合
     */
    @Override
    public Set<Object> hKeys(String key) {
        try {
            return redisTemplate.opsForHash().keys(key);
        } catch (Exception e) {
            log.error("获取哈希表所有键失败: key={}", key, e);
            return Set.of();
        }
    }

    /**
     * 获取哈希表字段数量
     * @param key 键
     * @return 字段数量
     */
    @Override
    public Long hSize(String key) {
        try {
            return redisTemplate.opsForHash().size(key);
        } catch (Exception e) {
            log.error("获取哈希表字段数量失败: key={}", key, e);
            return 0L;
        }
    }

    /**
     * 检查哈希字段是否存在
     * @param key 键
     * @param hashKey 哈希键
     * @return 是否存在
     */
    @Override
    public Boolean hHasKey(String key, String hashKey) {
        try {
            Boolean exists = redisTemplate.opsForHash().hasKey(key, hashKey);
            return exists != null ? exists : false;
        } catch (Exception e) {
            log.error("检查哈希字段是否存在失败: key={}, hashKey={}", key, hashKey, e);
            return false;
        }
    }

    /**
     * Hash字段递增
     * @param key 键
     * @param field 字段
     * @param delta 增量
     * @return 递增后的值
     */
    @Override
    public Long hIncr(String key, String field, long delta) {
        try {
            return redisTemplate.opsForHash().increment(key, field, delta);
        } catch (Exception e) {
            log.error("Hash字段递增失败: key={}, field={}, delta={}", key, field, delta, e);
            return null;
        }
    }

    /**
     * Hash字段递增
     * @param key 键
     * @param field 字段
     * @param delta 增量
     * @return 递增后的值
     */
    @Override
    public Long hIncr(String key, String field, int delta) {
        try {
            return redisTemplate.opsForHash().increment(key, field, delta);
        } catch (Exception e) {
            log.error("Hash字段递增失败: key={}, field={}, delta={}", key, field, delta, e);
            return null;
        }
    }

    /**
     * 获取哈希表所有值
     * @param key 键
     * @return 值列表
     */
    @Override
    public List<Object> hValues(String key) {
        try {
            return redisTemplate.opsForHash().values(key);
        } catch (Exception e) {
            log.error("获取哈希表所有值失败: key={}", key, e);
            return List.of();
        }
    }

    // List操作
    /**
     * 从左侧推入List
     * @param key 键
     * @param value 值
     * @return List长度
     */
    @Override
    public Long lLeftPush(String key, Object value) {
        try {
            return redisTemplate.opsForList().leftPush(key, value);
        } catch (Exception e) {
            log.error("从左侧推入List失败: key={}, value={}", key, value, e);
            return 0L;
        }
    }

    /**
     * 从右侧推入列表
     * @param key 键
     * @param value 值
     * @return 列表长度
     */
    @Override
    public Long rPush(String key, Object value) {
        try {
            return redisTemplate.opsForList().rightPush(key, value);
        } catch (Exception e) {
            log.error("从右侧推入列表失败: key={}, value={}", key, value, e);
            return 0L;
        }
    }

    /**
     * 从右侧推入List（别名方法）
     * @param key 键
     * @param value 值
     * @return List长度
     */
    @Override
    public Long lRightPush(String key, Object value) {
        try {
            return redisTemplate.opsForList().rightPush(key, value);
        } catch (Exception e) {
            log.error("从右侧推入List失败: key={}, value={}", key, value, e);
            return 0L;
        }
    }

    /**
     * 左推入List（别名方法）
     * @param key 键
     * @param value 值
     * @return List长度
     */
    @Override
    public Long lPush(String key, Object value) {
        try {
            return redisTemplate.opsForList().leftPush(key, value);
        } catch (Exception e) {
            log.error("左推入List失败: key={}, value={}", key, value, e);
            return 0L;
        }
    }

    /**
     * 从左侧弹出List
     * @param key 键
     * @return 值
     */
    @Override
    public Object lLeftPop(String key) {
        try {
            return redisTemplate.opsForList().leftPop(key);
        } catch (Exception e) {
            log.error("从左侧弹出List失败: key={}", key, e);
            return null;
        }
    }

    /**
     * 从右侧弹出List
     * @param key 键
     * @return 值
     */
    @Override
    public Object rPop(String key) {
        try {
            return redisTemplate.opsForList().rightPop(key);
        } catch (Exception e) {
            log.error("从右侧弹出List失败: key={}", key, e);
            return null;
        }
    }

    /**
     * 从右侧弹出List（别名方法）
     * @param key 键
     * @return 值
     */
    @Override
    public Object lRightPop(String key) {
        try {
            return redisTemplate.opsForList().rightPop(key);
        } catch (Exception e) {
            log.error("从右侧弹出List失败: key={}", key, e);
            return null;
        }
    }

    /**
     * 获取List长度
     * @param key 键
     * @return List长度
     */
    @Override
    public Long lSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            log.error("获取List长度失败: key={}", key, e);
            return 0L;
        }
    }

    /**
     * 获取List范围内的元素
     * @param key 键
     * @param start 开始位置
     * @param end 结束位置
     * @return 元素列表
     */
    @Override
    public List<Object> lRange(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            log.error("获取List范围内的元素失败: key={}, start={}, end={}", key, start, end, e);
            return List.of();
        }
    }

    /**
     * 修剪List，保留指定范围内的元素
     * @param key 键
     * @param start 开始索引
     * @param end 结束索引
     */
    @Override
    public void lTrim(String key, long start, long end) {
        try {
            redisTemplate.opsForList().trim(key, start, end);
        } catch (Exception e) {
            log.error("修剪List失败: key={}, start={}, end={}", key, start, end, e);
        }
    }

    // Set操作
    /**
     * 添加到集合
     * @param key 键
     * @param values 值
     * @return 添加的数量
     */
    @Override
    public Long sAdd(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            log.error("添加到集合失败: key={}, values={}", key, values, e);
            return 0L;
        }
    }

    /**
     * 从集合中移除
     * @param key 键
     * @param values 值
     * @return 移除的数量
     */
    @Override
    public Long sRemove(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().remove(key, values);
        } catch (Exception e) {
            log.error("从集合中移除失败: key={}, values={}", key, values, e);
            return 0L;
        }
    }

    /**
     * 检查集合中是否存在值
     * @param key 键
     * @param value 值
     * @return 是否存在
     */
    @Override
    public Boolean sIsMember(String key, Object value) {
        try {
            Boolean exists = redisTemplate.opsForSet().isMember(key, value);
            return exists != null ? exists : false;
        } catch (Exception e) {
            log.error("检查集合中是否存在值失败: key={}, value={}", key, value, e);
            return false;
        }
    }

    /**
     * 获取集合所有成员
     * @param key 键
     * @return 成员集合
     */
    @Override
    public Set<Object> sMembers(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            log.error("获取集合所有成员失败: key={}", key, e);
            return Set.of();
        }
    }

    /**
     * 获取集合大小
     * @param key 键
     * @return 集合大小
     */
    @Override
    public Long sSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            log.error("获取集合大小失败: key={}", key, e);
            return 0L;
        }
    }

    // ZSet操作
    /**
     * 添加到有序集合
     * @param key 键
     * @param value 值
     * @param score 分数
     * @return 是否添加成功
     */
    @Override
    public Boolean zAdd(String key, Object value, double score) {
        try {
            Boolean result = redisTemplate.opsForZSet().add(key, value, score);
            return result != null ? result : false;
        } catch (Exception e) {
            log.error("添加到有序集合失败: key={}, value={}, score={}", key, value, score, e);
            return false;
        }
    }

    /**
     * 从有序集合中移除
     * @param key 键
     * @param values 值
     * @return 移除的数量
     */
    @Override
    public Long zRemove(String key, Object... values) {
        try {
            return redisTemplate.opsForZSet().remove(key, values);
        } catch (Exception e) {
            log.error("从有序集合中移除失败: key={}, values={}", key, values, e);
            return 0L;
        }
    }

    /**
     * 获取有序集合范围内的元素
     * @param key 键
     * @param start 开始位置
     * @param end 结束位置
     * @return 元素集合
     */
    @Override
    public Set<Object> zRange(String key, long start, long end) {
        try {
            return redisTemplate.opsForZSet().range(key, start, end);
        } catch (Exception e) {
            log.error("获取有序集合范围内的元素失败: key={}, start={}, end={}", key, start, end, e);
            return Set.of();
        }
    }

    /**
     * 获取有序集合范围内的元素（按分数）
     * @param key 键
     * @param min 最小分数
     * @param max 最大分数
     * @return 元素集合
     */
    @Override
    public Set<Object> zRangeByScore(String key, double min, double max) {
        try {
            return redisTemplate.opsForZSet().rangeByScore(key, min, max);
        } catch (Exception e) {
            log.error("获取ZSet范围内的元素失败: key={}, min={}, max={}", key, min, max, e);
            return Set.of();
        }
    }

    /**
     * 获取有序集合大小
     * @param key 键
     * @return 集合大小
     */
    @Override
    public Long zSize(String key) {
        try {
            return redisTemplate.opsForZSet().size(key);
        } catch (Exception e) {
            log.error("获取有序集合大小失败: key={}", key, e);
            return 0L;
        }
    }

    /**
     * 获取有序集合成员的分数
     * @param key 键
     * @param value 值
     * @return 分数
     */
    @Override
    public Double zScore(String key, Object value) {
        try {
            return redisTemplate.opsForZSet().score(key, value);
        } catch (Exception e) {
            log.error("获取有序集合成员的分数失败: key={}, value={}", key, value, e);
            return null;
        }
    }

    // 业务相关缓存方法
    /**
     * 缓存用户信息
     * @param userId 用户ID
     * @param userInfo 用户信息
     */
    public void cacheUserInfo(Long userId, Object userInfo) {
        String key = AppConstants.USER_CACHE_PREFIX + userId;
        set(key, userInfo, Duration.ofMinutes(30));
    }

    /**
     * 获取用户信息缓存
     * @param userId 用户ID
     * @return 用户信息
     */
    public Object getUserInfoCache(Long userId) {
        String key = AppConstants.USER_CACHE_PREFIX + userId;
        return get(key);
    }

    /**
     * 删除用户信息缓存
     * @param userId 用户ID
     */
    public void deleteUserInfoCache(Long userId) {
        String key = AppConstants.USER_CACHE_PREFIX + userId;
        delete(key);
    }

    /**
     * 缓存胶囊信息
     * @param capsuleId 胶囊ID
     * @param capsuleInfo 胶囊信息
     */
    public void cacheCapsuleInfo(Long capsuleId, Object capsuleInfo) {
        String key = AppConstants.CAPSULE_CACHE_PREFIX + capsuleId;
        set(key, capsuleInfo, Duration.ofMinutes(30));
    }

    /**
     * 获取胶囊信息缓存
     * @param capsuleId 胶囊ID
     * @return 胶囊信息
     */
    public Object getCapsuleInfoCache(Long capsuleId) {
        String key = AppConstants.CAPSULE_CACHE_PREFIX + capsuleId;
        return get(key);
    }

    /**
     * 删除胶囊信息缓存
     * @param capsuleId 胶囊ID
     */
    public void deleteCapsuleInfoCache(Long capsuleId) {
        String key = AppConstants.CAPSULE_CACHE_PREFIX + capsuleId;
        delete(key);
    }

    /**
     * 缓存验证码
     * @param phone 手机号
     * @param code 验证码
     */
    public void cacheVerificationCode(String phone, String code) {
        String key = AppConstants.VERIFICATION_CODE_PREFIX + phone;
        setStringEx(key, code, 300); // 5分钟过期
    }

    /**
     * 获取验证码缓存
     * @param phone 手机号
     * @return 验证码
     */
    public String getVerificationCodeCache(String phone) {
        String key = AppConstants.VERIFICATION_CODE_PREFIX + phone;
        return getString(key);
    }

    /**
     * 删除验证码缓存
     * @param phone 手机号
     */
    public void deleteVerificationCodeCache(String phone) {
        String key = AppConstants.VERIFICATION_CODE_PREFIX + phone;
        delete(key);
    }

    /**
     * 缓存会话信息
     * @param sessionId 会话ID
     * @param sessionInfo 会话信息
     */
    public void cacheSessionInfo(String sessionId, Object sessionInfo) {
        String key = AppConstants.SESSION_CACHE_PREFIX + sessionId;
        set(key, sessionInfo, Duration.ofHours(2));
    }

    /**
     * 获取会话信息缓存
     * @param sessionId 会话ID
     * @return 会话信息
     */
    public Object getSessionInfoCache(String sessionId) {
        String key = AppConstants.SESSION_CACHE_PREFIX + sessionId;
        return get(key);
    }

    /**
     * 删除会话信息缓存
     * @param sessionId 会话ID
     */
    public void deleteSessionInfoCache(String sessionId) {
        String key = AppConstants.SESSION_CACHE_PREFIX + sessionId;
        delete(key);
    }

    /**
     * 缓存API限流信息
     * @param key 限流键
     * @param count 计数
     * @param expireSeconds 过期时间（秒）
     */
    public void cacheRateLimitInfo(String key, int count, int expireSeconds) {
        String rateLimitKey = AppConstants.RATE_LIMIT_PREFIX + key;
        setEx(rateLimitKey, count, expireSeconds);
    }

    /**
     * 获取API限流信息
     * @param key 限流键
     * @return 计数
     */
    public Integer getRateLimitInfo(String key) {
        String rateLimitKey = AppConstants.RATE_LIMIT_PREFIX + key;
        Object count = get(rateLimitKey);
        return count != null ? (Integer) count : 0;
    }

    /**
     * 递增API限流计数
     * @param key 限流键
     * @return 递增后的计数
     */
    public Long incrementRateLimit(String key) {
        String rateLimitKey = AppConstants.RATE_LIMIT_PREFIX + key;
        return increment(rateLimitKey, 1);
    }

    /**
     * 缓存配置信息
     * @param configKey 配置键
     * @param configValue 配置值
     */
    public void cacheConfig(String configKey, Object configValue) {
        String key = AppConstants.CONFIG_CACHE_PREFIX + configKey;
        set(key, configValue, Duration.ofHours(1));
    }

    /**
     * 获取配置信息缓存
     * @param configKey 配置键
     * @return 配置值
     */
    public Object getConfigCache(String configKey) {
        String key = AppConstants.CONFIG_CACHE_PREFIX + configKey;
        return get(key);
    }

    /**
     * 删除配置信息缓存
     * @param configKey 配置键
     */
    public void deleteConfigCache(String configKey) {
        String key = AppConstants.CONFIG_CACHE_PREFIX + configKey;
        delete(key);
    }

    /**
     * 清空所有缓存
     * @param pattern 模式（可选）
     */
    public void clearCache(String pattern) {
        try {
            Set<String> keys = keys(pattern != null ? pattern : "*");
            if (!keys.isEmpty()) {
                delete(keys);
                log.info("清空缓存: pattern={}, count={}", pattern, keys.size());
            }
        } catch (Exception e) {
            log.error("清空缓存失败: pattern={}", pattern, e);
        }
    }

    /**
     * 获取缓存统计信息
     * @return 统计信息
     */
    public Map<String, Object> getCacheStats() {
        try {
            Map<String, Object> stats = new HashMap<>();
            
            // 获取不同类型缓存的数量
            stats.put("userCacheCount", keys(AppConstants.USER_CACHE_PREFIX + "*").size());
            stats.put("capsuleCacheCount", keys(AppConstants.CAPSULE_CACHE_PREFIX + "*").size());
            stats.put("sessionCacheCount", keys(AppConstants.SESSION_CACHE_PREFIX + "*").size());
            stats.put("configCacheCount", keys(AppConstants.CONFIG_CACHE_PREFIX + "*").size());
            stats.put("totalCacheCount", keys("*").size());
            
            return stats;
        } catch (Exception e) {
            log.error("获取缓存统计信息失败", e);
            return Map.of();
        }
    }

    /**
     * 获取缓存信息
     * @return 缓存信息
     */
    @Override
    public Map<String, Object> getCacheInfo() {
        try {
            Map<String, Object> info = new java.util.HashMap<>();
            info.put("connected", true);
            info.put("type", "Redis");
            info.put("timestamp", System.currentTimeMillis());
            return info;
        } catch (Exception e) {
            log.error("获取缓存信息失败", e);
            Map<String, Object> errorInfo = new java.util.HashMap<>();
            errorInfo.put("connected", false);
            errorInfo.put("error", e.getMessage());
            return errorInfo;
        }
    }

    @Override
    public void set(String key, Object value, Duration timeout) {
        set(key, value, timeout.toMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public Boolean expire(String key, Duration timeout) {
        return expire(key, timeout.toMillis(), TimeUnit.MILLISECONDS);
    }

    /**
     * 批量设置哈希字段（别名方法）
     * @param key 键
     * @param map 哈希表
     * @return 是否设置成功
     */
    @Override
    public Boolean hSetAll(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            log.error("批量设置哈希字段失败: key={}, map={}", key, map, e);
            return false;
        }
    }

    @Override
    public Map<String, Object> getInfo() {
        return getCacheInfo();
    }

    /**
     * 生成缓存键
     * @param prefix 前缀
     * @param suffix 后缀
     * @return 缓存键
     */
    @Override
    public String generateKey(String prefix, String suffix) {
        return prefix + ":" + suffix;
    }

    /**
     * 清空所有缓存
     */
    @Override
    public void flushAll() {
        try {
            redisTemplate.execute((org.springframework.data.redis.core.RedisCallback<Void>) connection -> {
                connection.serverCommands().flushAll();
                return null;
            });
        } catch (Exception e) {
            log.error("清空所有缓存失败", e);
        }
    }

    /**
     * 清理过期缓存
     */
    @Override
    public void cleanExpiredCache() {
        // Redis会自动清理过期缓存，这里不需要额外处理
        log.info("Redis会自动清理过期缓存");
    }
}